home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Snippets / BackInUse 1.0.3 / BackInUse.c < prev    next >
Text File  |  1996-07-07  |  5KB  |  184 lines
  1. /* ----------------------------------------------------------------------
  2.  
  3.     BackInUse
  4.     version 1.0.3
  5.     
  6.     This snippet draws a six point poly, then insets the points a certain
  7.     amount and keeps redrawing until it gets to nothing. Then, it erases
  8.     the picture and starts the entire process again. Though I don't
  9.     believe this program has any commercial value, I have reserved
  10.     commercial rights anyway. So, if you want to give it away, please
  11.     keep my name in the darn thing; I need to feel appreciated.
  12.  
  13.     Written by: William Woody
  14.     Ported to CW by: Ken Long
  15.     Updated for CW9 by: Paul Celestin
  16.  
  17.     930724 - 1.0.0 - original version    
  18.     950711 - 1.0.1 - ported to CW
  19.     951201 - 1.0.2 - updated for CW7
  20.     960707 - 1.0.3 - updated for CW9
  21.  
  22. ---------------------------------------------------------------------- */
  23.  
  24.  
  25. #include <stdio.h>
  26. #include <quickdraw.h>        //• What they don't tell you is that you need to
  27.                             //• include this for the SRAND macro to work...
  28.  
  29. //extern int Random ();
  30. extern char *malloc ();
  31.  
  32. #define MAXX 480
  33. #define MAXY 300
  34. #define MAXM 400
  35.  
  36. WindowPtr theWindow;
  37. WindowRecord wRecord;
  38. Rect dragRect, linesRect;
  39. Rect windowBounds = { 40, 2, 380, 508 };
  40.  
  41. struct foo {
  42.     double a,b;            //• This is a point which gets to fly around
  43.     struct foo *next;
  44. };
  45.  
  46. main ()
  47. {
  48.     short number,n,x,done = 0;
  49.     struct foo *top,*Ptr,*Ptr2;
  50.     
  51. //    struct {
  52. //        short top, left, bottom, right;
  53. //    } linesRect;
  54.     
  55.     long ticks;        //• For the delay in the "splash" screen.
  56.     
  57.     double mx,my,nx,ny;
  58.     
  59.     MaxApplZone();
  60.  
  61.     InitGraf(&qd.thePort);
  62.     InitFonts();
  63.     FlushEvents(everyEvent, 0);
  64.     InitWindows();
  65.     InitMenus();
  66.     TEInit();
  67.     InitDialogs(0L);
  68.     InitCursor();
  69.  
  70.     //• We can't drag because mouseDown quits us.  
  71.     //• But it's here if we want to rig it in later.
  72.     dragRect = qd.screenBits.bounds;    
  73.     
  74.     theWindow = NewWindow (&wRecord, &windowBounds, "\pBackInUse", true, 0, 
  75.                      (WindowPtr)-1L, false, 0L);
  76.     SetPort (theWindow);
  77.  
  78.  
  79.     //• We add a Rect to the window that we can draw in and erase.
  80.     SetRect (&linesRect,0,0,500,350);
  81.     EraseRect (&linesRect); // let's start with a clean slate
  82.         
  83.     MoveTo (10,25);
  84.     TextFont (systemFont);    //• System Font is zero, folks.
  85.     TextSize (12);
  86.     DrawString ("\pBackInUse");
  87.     MoveTo (10,40);
  88.     DrawString ("\pCopyright©1985-1996 by William Woody, commercial rights reserved.");
  89.     MoveTo (10,55);
  90.     DrawString ("\pTo halt the program, press the mouse Button.");
  91.     TextFont (courier);        //• Change font to Courier 12 bold.
  92.     TextSize (12);    
  93.     TextFace (bold);
  94.     MoveTo (10,70);
  95.     DrawString ("\pPorted to CodeWarrior");
  96.     MoveTo (10,85);
  97.     DrawString ("\pBy Kenneth A. Long");    
  98.     GetDateTime ((unsigned long*) &qd.randSeed);    //• Seed the random number generator
  99.     TextFont (0);
  100.     TextSize (12);    //• Set all the font stuff back so our SysParams are OK.
  101.     TextFace (0);
  102.     Delay (240L, &ticks);
  103.     EraseRect (&linesRect);        //• Get ready for action, after bragging.
  104.     
  105.     while  (!done) 
  106.     {
  107.         EraseRect (&linesRect);        //• Added to not stack drawings up.
  108.         number =  (Random () & 3) + 2;    //• Number of points generated.
  109.         x = 0;
  110.             
  111.         top = Ptr = (struct foo *) malloc(sizeof(struct foo));
  112.  
  113.         //• While horizontal incrementing value is not the same 
  114.         //• as number of points...
  115.         while  (x++ != number)
  116.     
  117.         //• ...this stuff is what it is (?).
  118.         Ptr =  (Ptr->next = (struct foo *) malloc (sizeof(struct foo)));
  119.         Ptr =  (Ptr->next = top);
  120.         
  121.         mx = 0;
  122.         my = 0;
  123.         nx = 9999999.0;        //• Large numbers for finding minimum value.
  124.         ny = 9999999.0;
  125.         do 
  126.         {
  127.             Ptr->a =  (double) Random ();
  128.             if  (Ptr->a > mx) mx = Ptr->a;
  129.             if  (Ptr->a < nx) nx = Ptr->a;
  130.             Ptr->b =  (double) Random ();
  131.             if  (Ptr->b > my) my = Ptr->b;
  132.             if  (Ptr->b < ny) ny = Ptr->b;
  133.             Ptr = Ptr->next;
  134.             
  135.         } 
  136.         //• As long as Ptr ain't the same as top...
  137.         while  (Ptr != top);
  138.             do         //• ...make up the points and create "a".
  139.             {        //• A circularly linked list of points.
  140.                 Ptr->a =  (Ptr->a - nx) * MAXX /  (mx - nx);
  141.                 Ptr->b =  (Ptr->b - ny) * MAXY /  (my - ny);
  142.                 Ptr = Ptr->next;    //• Ptr points to next point.
  143.             } 
  144.         //• Again, as long as Ptr ain't the same as top...
  145.         while  (Ptr != top);
  146.             n = 0;        //• ..."n" has 0 value.
  147.             MoveTo ( (int) Ptr->a, (int) Ptr->b);
  148.             
  149.             //• While that's true, and while incrementing "n" is not the 
  150.             //• same as 400 times the number of points generated...
  151.             while  (n++ != MAXM * number)    
  152.             {    //• ...move the points around, like this:
  153.                 
  154.                 //• Give "Ptr->a" a value of ITSELF times 40, PLUS
  155.                 //• the value of "Ptr->next->a" (see above "do loop"),
  156.                 //• then divide that product by 41.  That's the H coord.
  157.                 Ptr->a =  (Ptr->a * 40 + Ptr->next->a) / 41;
  158.                 
  159.                 //• Same for be to get the V coord.
  160.                 Ptr->b =  (Ptr->b * 40 + Ptr->next->b) / 41;
  161.                 
  162.                 //• Then draw the line.
  163.                 LineTo ( (int)Ptr->a, (int)Ptr->b);
  164.                 
  165.                 Ptr = Ptr->next;
  166.                 if  (Button ())    //• Halt program when Button is pressed.
  167.                 {
  168.                     done = 1;    //• It's one DONE puppy!
  169.                     break;        //• Unconditionally get the hell out.
  170.                 }
  171.             }    //• done with "while".
  172.             
  173.             Ptr = top;    //• Clean up the circular linked list.
  174.             do 
  175.             {
  176.                 Ptr =  (Ptr2 = Ptr)->next;
  177.                 free (Ptr2);
  178.             } 
  179.             while  (Ptr != top);    //• As long as Ptr aint the top.
  180.         EraseRect (&linesRect);
  181.     }
  182. }
  183.  
  184.